{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "229106aa-a0ac-4c84-a5ad-adfe706540db",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 2576 entries, 0 to 2575\n",
      "Columns: 2001 entries, 0 to Label\n",
      "dtypes: float64(2000), object(1)\n",
      "memory usage: 39.3+ MB\n",
      "None\n",
      "          0         1         2         3         4         5         6  \\\n",
      "0 -0.015552  0.016963  0.013575  0.027204  0.068154  0.129259  0.127915   \n",
      "1  0.002323  0.002754  0.022539  0.228807  0.107751  0.034439  0.086007   \n",
      "2  0.050481 -0.339781  0.265111  0.045092  0.040086  0.087173  0.092814   \n",
      "3  0.023882  0.016561  0.248547  0.054567  0.128032  0.085954  0.107359   \n",
      "4 -0.058591  0.171551  0.057262  0.270869  0.138357  0.078509  0.062504   \n",
      "\n",
      "          7         8         9  ...      1991      1992      1993      1994  \\\n",
      "0  0.345174  0.197811  0.167651  ... -0.426464 -0.346976 -0.132168 -0.252098   \n",
      "1  0.155667  0.163327  0.223759  ... -0.169345 -0.356808 -0.338996 -0.292489   \n",
      "2  0.099586 -0.143305  0.164186  ... -0.401426 -0.402333 -0.373426 -0.303710   \n",
      "3  0.207137  0.174547 -0.100118  ... -0.390700 -0.353882 -0.294014 -0.267005   \n",
      "4  0.104447  0.134795  0.194248  ... -0.391598 -0.334490 -0.326873 -0.249881   \n",
      "\n",
      "       1995      1996      1997      1998      1999  Label  \n",
      "0 -0.241969 -0.134235 -0.091327 -0.081713 -0.057693     MI  \n",
      "1 -0.152872 -0.156076 -0.103265 -0.041579 -0.044272     MI  \n",
      "2  0.008599 -0.180633 -0.143135 -0.084758  0.060668     MI  \n",
      "3 -0.242258 -0.186946 -0.173718  0.101331  0.063555     MI  \n",
      "4 -0.210052 -0.194763 -0.415365  0.015432  0.010321     MI  \n",
      "\n",
      "[5 rows x 2001 columns]\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "#Load raw PPG dataset\n",
    "file_path = \"PPG_Dataset.csv\"  \n",
    "df = pd.read_csv(file_path)\n",
    "\n",
    "#Show basic info and a few rows\n",
    "print(df.info())\n",
    "print(df.head())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d4af2728-1d39-449a-b113-ae743e515bd0",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from scipy.signal import butter, filtfilt\n",
    "import pywt  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "f1eeb501-f936-4f20-bd89-c93163bf0990",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Separate signals and labels\n",
    "X_raw = df.drop(columns=['Label']).values\n",
    "y = df['Label'].values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a6b9a514-2e73-4699-bd1d-37e0d07c509a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "          0         1         2         3         4         5         6  \\\n",
      "0 -0.100787 -0.089354 -0.070646 -0.049112 -0.027846 -0.012790 -0.001084   \n",
      "1 -0.086195 -0.076472 -0.060655 -0.042390 -0.024348 -0.011621 -0.001777   \n",
      "2 -0.104214 -0.104316 -0.103408 -0.101159 -0.097810 -0.093809 -0.088429   \n",
      "3 -0.061735 -0.058045 -0.051712 -0.043310 -0.034243 -0.026986 -0.020093   \n",
      "4 -0.082395 -0.069895 -0.049607 -0.027041 -0.005327  0.009354  0.019858   \n",
      "\n",
      "          7         8         9  ...      1991      1992      1993      1994  \\\n",
      "0  0.013489  0.027770  0.040623  ... -0.247648 -0.214584 -0.181719 -0.149433   \n",
      "1  0.010404  0.022234  0.032752  ... -0.246439 -0.208430 -0.172750 -0.139207   \n",
      "2 -0.080780 -0.070704 -0.057733  ... -0.333118 -0.297626 -0.258332 -0.216378   \n",
      "3 -0.011215 -0.001299  0.009620  ... -0.332811 -0.299347 -0.262005 -0.221873   \n",
      "4  0.032894  0.044970  0.054666  ... -0.325377 -0.292447 -0.255882 -0.216701   \n",
      "\n",
      "       1995      1996      1997      1998      1999  Label  \n",
      "0 -0.118103 -0.088529 -0.061265 -0.037901 -0.020545     MI  \n",
      "1 -0.107099 -0.077072 -0.049080 -0.024946 -0.007627     MI  \n",
      "2 -0.173569 -0.131014 -0.090160 -0.054107 -0.026455     MI  \n",
      "3 -0.180185 -0.138067 -0.097056 -0.060407 -0.032213     MI  \n",
      "4 -0.176423 -0.136077 -0.097001 -0.062284 -0.035650     MI  \n",
      "\n",
      "[5 rows x 2001 columns]\n"
     ]
    }
   ],
   "source": [
    "# Step 1: Band-pass Filter (0.5–4 Hz)\n",
    "def bandpass_filter(data, lowcut=0.5, highcut=4.0, fs=100.0, order=4):\n",
    "    nyq = 0.5 * fs\n",
    "    low = lowcut / nyq\n",
    "    high = highcut / nyq\n",
    "    b, a = butter(order, [low, high], btype='band')\n",
    "    return filtfilt(b, a, data)\n",
    "\n",
    "filtered_signals = np.array([bandpass_filter(row) for row in X_raw])\n",
    "\n",
    "# Step 2: Wavelet Denoising\n",
    "def wavelet_denoise(signal, wavelet='db6', level=3):\n",
    "    coeff = pywt.wavedec(signal, wavelet, level=level)\n",
    "    sigma = np.median(np.abs(coeff[-level])) / 0.6745\n",
    "    uthresh = sigma * np.sqrt(2 * np.log(len(signal)))\n",
    "    denoised_coeffs = coeff[:]\n",
    "    denoised_coeffs[1:] = [pywt.threshold(i, value=uthresh, mode='soft') for i in denoised_coeffs[1:]]\n",
    "    return pywt.waverec(denoised_coeffs, wavelet)\n",
    "\n",
    "# Apply wavelet denoising\n",
    "filtered_denoised_signals = np.array([wavelet_denoise(sig)[:X_raw.shape[1]] for sig in filtered_signals])\n",
    "\n",
    "# Final preprocessed dataframe\n",
    "df_preprocessed = pd.DataFrame(filtered_denoised_signals)\n",
    "df_preprocessed['Label'] = y\n",
    "\n",
    "# Preview\n",
    "print(df_preprocessed.head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6774ceb5-22bd-4273-9ad3-2964af5f9d52",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Segmented data shape: (5152, 1000)\n",
      "Segmented labels shape: (5152,)\n"
     ]
    }
   ],
   "source": [
    "# df_preprocessed has signal rows and 'Label'\n",
    "signals = df_preprocessed.drop(columns=['Label']).values\n",
    "labels = df_preprocessed['Label'].values\n",
    "\n",
    "# Parameters\n",
    "window_size = 1000  \n",
    "segmented_signals = []\n",
    "segmented_labels = []\n",
    "\n",
    "for signal, label in zip(signals, labels):\n",
    "    total_len = len(signal)\n",
    "    num_windows = total_len // window_size  # how many full windows we can get\n",
    "    for i in range(num_windows):\n",
    "        start = i * window_size\n",
    "        end = start + window_size\n",
    "        segment = signal[start:end]\n",
    "        segmented_signals.append(segment)\n",
    "        segmented_labels.append(label)\n",
    "\n",
    "# Convert to arrays\n",
    "X_segmented = np.array(segmented_signals)\n",
    "y_segmented = np.array(segmented_labels)\n",
    "\n",
    "# Shape confirmation\n",
    "print(\"Segmented data shape:\", X_segmented.shape)\n",
    "print(\"Segmented labels shape:\", y_segmented.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "de078382-11a6-48fd-b167-87884d12c3a4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Normalized data shape: (5152, 1000)\n",
      "Sample mean: 7.105427357601002e-18\n",
      "Sample std: 1.0\n"
     ]
    }
   ],
   "source": [
    "from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "# Initialize scaler\n",
    "scaler = StandardScaler()\n",
    "\n",
    "# Apply scaler row-wise using list comprehension\n",
    "X_normalized = np.array([scaler.fit_transform(x.reshape(-1, 1)).flatten() for x in X_segmented])\n",
    "\n",
    "# Check shape and stats\n",
    "print(\"Normalized data shape:\", X_normalized.shape)\n",
    "print(\"Sample mean:\", np.mean(X_normalized[0]))\n",
    "print(\"Sample std:\", np.std(X_normalized[0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "37a49afa-17b0-4c6e-abf7-58efaa895ca5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Entropy feature shape: (5152, 4)\n",
      "Sample (PE, RPE, DE, RDE): [1.23233768 1.23233768 0.37005136 0.37005136]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import math\n",
    "from scipy.stats import zscore\n",
    "\n",
    "def dispersion_entropy(sig, m=3, c=6, tau=1, normalize=True):\n",
    "    N = len(sig)\n",
    "    sig = zscore(sig)  # z-score normalization\n",
    "    max_val = np.max(sig)\n",
    "    min_val = np.min(sig)\n",
    "    bins = np.linspace(min_val, max_val, c + 1)\n",
    "\n",
    "    # Quantize signal\n",
    "    quantized = np.digitize(sig, bins) - 1\n",
    "    quantized[quantized == c] = c - 1  # Fix upper limit\n",
    "\n",
    "    patterns = []\n",
    "    for i in range(N - (m - 1) * tau):\n",
    "        pattern = tuple(quantized[i + j * tau] for j in range(m))\n",
    "        patterns.append(pattern)\n",
    "\n",
    "    unique, counts = np.unique(patterns, axis=0, return_counts=True)\n",
    "    probs = counts / counts.sum()\n",
    "    entropy = -np.sum(probs * np.log2(probs))\n",
    "\n",
    "    if normalize:\n",
    "        entropy = entropy / np.log2(c ** m)\n",
    "\n",
    "    return entropy\n",
    "\n",
    "# Feature extraction from segments\n",
    "def extract_entropy_features_custom(segments):\n",
    "    features = []\n",
    "    for seg in segments:\n",
    "        pe = ant.perm_entropy(seg)\n",
    "        rpe = ant.perm_entropy(seg[::-1])\n",
    "        de = dispersion_entropy(seg, m=3, c=6)\n",
    "        rde = dispersion_entropy(seg[::-1], m=3, c=6)\n",
    "        features.append([pe, rpe, de, rde])\n",
    "    return np.array(features)\n",
    "\n",
    "# Apply on normalized segments\n",
    "X_entropy = extract_entropy_features_custom(X_normalized)\n",
    "\n",
    "# Output\n",
    "print(\"Entropy feature shape:\", X_entropy.shape)\n",
    "print(\"Sample (PE, RPE, DE, RDE):\", X_entropy[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "dd6ea25b-83ea-4be5-9fd8-a362eedf9cb0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "✅ Shape of feature matrix: (2576, 17)\n",
      "✅ Sample Time-Domain Features (First Row): [ 0.01557873  0.43901009 -0.08941497 -1.42704009  0.43928641]\n",
      "✅ Sample Frequency-Domain Features (First Row): [ 31.15745959 117.80290503  72.92126505 186.29955527  67.899132\n",
      " 273.05208008  35.46768174 148.27278135 161.15062881  63.02708417\n",
      "   0.30857182  16.74076723]\n",
      "✅ Sample Combined Feature Row (First Row): [ 1.55787298e-02  4.39010087e-01 -8.94149668e-02 -1.42704009e+00\n",
      "  4.39286414e-01  3.11574596e+01  1.17802905e+02  7.29212650e+01\n",
      "  1.86299555e+02  6.78991320e+01  2.73052080e+02  3.54676817e+01\n",
      "  1.48272781e+02  1.61150629e+02  6.30270842e+01  3.08571823e-01\n",
      "  1.67407672e+01]\n",
      "✅ Labels (first 10): [1 1 1 1 1 1 1 1 1 1]\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from scipy.stats import skew, kurtosis\n",
    "from scipy.signal import welch\n",
    "from scipy.fft import fft\n",
    "\n",
    "# Load the dataset\n",
    "df = pd.read_csv('PPG_Dataset.csv')\n",
    "\n",
    "# Separate signal and labels\n",
    "signals = df.iloc[:, :-1].values\n",
    "labels = df['Label'].values\n",
    "\n",
    "# Initialize lists to store features\n",
    "time_features = []\n",
    "freq_features = []\n",
    "\n",
    "# Loop through each signal row to extract features\n",
    "for signal in signals:\n",
    "    # Time-domain features\n",
    "    mean_val = np.mean(signal)\n",
    "    std_val = np.std(signal)\n",
    "    skew_val = skew(signal)\n",
    "    kurt_val = kurtosis(signal)\n",
    "    rms_val = np.sqrt(np.mean(signal**2))\n",
    "    time_features.append([mean_val, std_val, skew_val, kurt_val, rms_val])\n",
    "\n",
    "    # Frequency-domain features\n",
    "    fft_vals = np.abs(fft(signal))\n",
    "    fft_features = fft_vals[:10]  # First 10 FFT coefficients\n",
    "\n",
    "    # Power Spectral Density (PSD)\n",
    "    f, psd = welch(signal)\n",
    "    psd_mean = np.mean(psd)\n",
    "    psd_max = np.max(psd)\n",
    "    freq_features.append(np.concatenate([fft_features, [psd_mean, psd_max]]))\n",
    "\n",
    "# Convert to arrays\n",
    "time_features = np.array(time_features)\n",
    "freq_features = np.array(freq_features)\n",
    "\n",
    "# Combine time + frequency domain features\n",
    "X_additional = np.hstack((time_features, freq_features))\n",
    "\n",
    "# Convert labels to 0 (Normal) and 1 (MI)\n",
    "y = np.array([0 if label == 'Normal' else 1 for label in labels])\n",
    "\n",
    "# Display outputs\n",
    "print(\"✅ Shape of feature matrix:\", X_additional.shape)\n",
    "print(\"✅ Sample Time-Domain Features (First Row):\", time_features[0])\n",
    "print(\"✅ Sample Frequency-Domain Features (First Row):\", freq_features[0])\n",
    "print(\"✅ Sample Combined Feature Row (First Row):\", X_additional[0])\n",
    "print(\"✅ Labels (first 10):\", y[:10])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "af27d8c5-de9a-4c2c-8e2d-e25f1e20cfae",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original Label Distribution: Counter({np.int64(1): 1294, np.int64(0): 1282})\n",
      "✅ Balanced Label Distribution: Counter({np.int64(1): 1294, np.int64(0): 1294})\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.utils import resample\n",
    "from collections import Counter\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "# Check original distribution\n",
    "print(\"Original Label Distribution:\", Counter(y))\n",
    "\n",
    "# Separate majority and minority classes\n",
    "X_majority = X_additional[y == 0]\n",
    "X_minority = X_additional[y == 1]\n",
    "\n",
    "# If minority class is class 0, flip the variables\n",
    "if len(X_majority) < len(X_minority):\n",
    "    X_majority, X_minority = X_minority, X_majority\n",
    "    y_majority = [1] * len(X_majority)\n",
    "    y_minority = [0] * len(X_minority)\n",
    "else:\n",
    "    y_majority = [0] * len(X_majority)\n",
    "    y_minority = [1] * len(X_minority)\n",
    "\n",
    "# Upsample the minority class\n",
    "X_minority_upsampled = resample(X_minority,\n",
    "                                replace=True,\n",
    "                                n_samples=len(X_majority),\n",
    "                                random_state=42)\n",
    "\n",
    "# Combine majority and upsampled minority\n",
    "X_balanced = np.vstack((X_majority, X_minority_upsampled))\n",
    "y_balanced = np.array(y_majority + [y_minority[0]] * len(X_minority_upsampled))\n",
    "\n",
    "# Check new distribution\n",
    "from collections import Counter\n",
    "print(\"✅ Balanced Label Distribution:\", Counter(y_balanced))\n",
    "\n",
    "# Plot the balanced class distribution\n",
    "plt.bar(['Normal', 'MI'], [Counter(y_balanced)[0], Counter(y_balanced)[1]], color=['blue', 'orange'])\n",
    "plt.title(\"Label Distribution After Balancing (Upsampling)\")\n",
    "plt.ylabel(\"Count\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "dd00ec8b-5175-4739-86fc-27fd53f62d72",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "✅ Scaled Feature Matrix Shape: (2588, 17)\n",
      "✅ First Row (Scaled): [ 0.89801136  0.73939115 -1.63897439  1.21767689  0.74134686  0.89801136\n",
      "  1.05990806  0.87213921  0.98395622  0.9781672   1.04638394 -1.08493665\n",
      " -1.06836589 -1.09211045 -1.03107643 -1.06250394 -1.05083687]\n",
      "✅ Mean (approx): [-0.  0. -0. -0.  0.]\n",
      "✅ Std Dev (approx): [1. 1. 1. 1. 1.]\n"
     ]
    }
   ],
   "source": [
    "from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "# Initialize StandardScaler\n",
    "scaler = StandardScaler()\n",
    "\n",
    "# Fit and transform the balanced features\n",
    "X_scaled = scaler.fit_transform(X_balanced)\n",
    "\n",
    "# Show a few samples\n",
    "print(\"✅ Scaled Feature Matrix Shape:\", X_scaled.shape)\n",
    "print(\"✅ First Row (Scaled):\", X_scaled[0])\n",
    "print(\"✅ Mean (approx):\", np.round(X_scaled.mean(axis=0)[:5], 2))\n",
    "print(\"✅ Std Dev (approx):\", np.round(X_scaled.std(axis=0)[:5], 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "7e22142d-6977-4ffa-a1c2-e05d0cbc46a7",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Srishti\\AppData\\Roaming\\Python\\Python313\\site-packages\\xgboost\\training.py:183: UserWarning: [18:10:07] WARNING: C:\\actions-runner\\_work\\xgboost\\xgboost\\src\\learner.cc:738: \n",
      "Parameters: { \"use_label_encoder\" } are not used.\n",
      "\n",
      "  bst.update(dtrain, iteration=i, fobj=obj)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "🔹 RandomForest\n",
      "   ✅ Best Accuracy: 0.9702\n",
      "   📌 Best Parameters: {'max_depth': None, 'n_estimators': 100}\n",
      "\n",
      "🔹 SVM\n",
      "   ✅ Best Accuracy: 0.9625\n",
      "   📌 Best Parameters: {'C': 0.1, 'kernel': 'rbf'}\n",
      "\n",
      "🔹 XGBoost\n",
      "   ✅ Best Accuracy: 0.9706\n",
      "   📌 Best Parameters: {'max_depth': 5, 'n_estimators': 100}\n",
      "\n",
      "🔹 LogisticRegression\n",
      "   ✅ Best Accuracy: 0.9625\n",
      "   📌 Best Parameters: {'C': 0.1}\n",
      "\n",
      "🔹 KNN\n",
      "   ✅ Best Accuracy: 0.9617\n",
      "   📌 Best Parameters: {'n_neighbors': 5}\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import StratifiedKFold, GridSearchCV\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.svm import SVC\n",
    "from xgboost import XGBClassifier\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "\n",
    "# 5.1 Stratified K-Fold Cross Validation\n",
    "cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)\n",
    "\n",
    "# 5.2 Define classifiers and their hyperparameter grids\n",
    "models = {\n",
    "    'RandomForest': (RandomForestClassifier(), {\n",
    "        'n_estimators': [100, 200],\n",
    "        'max_depth': [None, 10]\n",
    "    }),\n",
    "    'SVM': (SVC(probability=True), {\n",
    "        'C': [0.1, 1],\n",
    "        'kernel': ['rbf', 'linear']\n",
    "    }),\n",
    "    'XGBoost': (XGBClassifier(use_label_encoder=False, eval_metric='logloss'), {\n",
    "        'n_estimators': [100],\n",
    "        'max_depth': [3, 5]\n",
    "    }),\n",
    "    'LogisticRegression': (LogisticRegression(max_iter=1000), {\n",
    "        'C': [0.1, 1, 10]\n",
    "    }),\n",
    "    'KNN': (KNeighborsClassifier(), {\n",
    "        'n_neighbors': [3, 5, 7]\n",
    "    })\n",
    "}\n",
    "\n",
    "# 5.3 Train models using GridSearchCV\n",
    "results = {}\n",
    "for name, (model, param_grid) in models.items():\n",
    "    grid = GridSearchCV(model, param_grid, cv=cv, scoring='accuracy', n_jobs=-1)\n",
    "    grid.fit(X_scaled, y_balanced)  # Use scaled, balanced data from Step 4\n",
    "    results[name] = {\n",
    "        'Best Score': grid.best_score_,\n",
    "        'Best Estimator': grid.best_estimator_,\n",
    "        'Best Params': grid.best_params_\n",
    "    }\n",
    "\n",
    "# Print results\n",
    "for model_name, details in results.items():\n",
    "    print(f\"🔹 {model_name}\")\n",
    "    print(f\"   ✅ Best Accuracy: {details['Best Score']:.4f}\")\n",
    "    print(f\"   📌 Best Parameters: {details['Best Params']}\")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "d57ef37c-e590-4f25-ac48-06e0250aa326",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Srishti\\AppData\\Roaming\\Python\\Python313\\site-packages\\xgboost\\training.py:183: UserWarning: [18:10:24] WARNING: C:\\actions-runner\\_work\\xgboost\\xgboost\\src\\learner.cc:738: \n",
      "Parameters: { \"use_label_encoder\" } are not used.\n",
      "\n",
      "  bst.update(dtrain, iteration=i, fobj=obj)\n",
      "C:\\Users\\Srishti\\AppData\\Roaming\\Python\\Python313\\site-packages\\xgboost\\training.py:183: UserWarning: [18:10:27] WARNING: C:\\actions-runner\\_work\\xgboost\\xgboost\\src\\learner.cc:738: \n",
      "Parameters: { \"use_label_encoder\" } are not used.\n",
      "\n",
      "  bst.update(dtrain, iteration=i, fobj=obj)\n",
      "C:\\Users\\Srishti\\AppData\\Roaming\\Python\\Python313\\site-packages\\xgboost\\training.py:183: UserWarning: [18:10:29] WARNING: C:\\actions-runner\\_work\\xgboost\\xgboost\\src\\learner.cc:738: \n",
      "Parameters: { \"use_label_encoder\" } are not used.\n",
      "\n",
      "  bst.update(dtrain, iteration=i, fobj=obj)\n",
      "C:\\Users\\Srishti\\AppData\\Roaming\\Python\\Python313\\site-packages\\xgboost\\training.py:183: UserWarning: [18:10:32] WARNING: C:\\actions-runner\\_work\\xgboost\\xgboost\\src\\learner.cc:738: \n",
      "Parameters: { \"use_label_encoder\" } are not used.\n",
      "\n",
      "  bst.update(dtrain, iteration=i, fobj=obj)\n",
      "C:\\Users\\Srishti\\AppData\\Roaming\\Python\\Python313\\site-packages\\xgboost\\training.py:183: UserWarning: [18:10:34] WARNING: C:\\actions-runner\\_work\\xgboost\\xgboost\\src\\learner.cc:738: \n",
      "Parameters: { \"use_label_encoder\" } are not used.\n",
      "\n",
      "  bst.update(dtrain, iteration=i, fobj=obj)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "✅ Hard Voting Accuracy (mean of 5-fold CV): 0.9718\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Srishti\\AppData\\Roaming\\Python\\Python313\\site-packages\\xgboost\\training.py:183: UserWarning: [18:10:36] WARNING: C:\\actions-runner\\_work\\xgboost\\xgboost\\src\\learner.cc:738: \n",
      "Parameters: { \"use_label_encoder\" } are not used.\n",
      "\n",
      "  bst.update(dtrain, iteration=i, fobj=obj)\n",
      "C:\\Users\\Srishti\\AppData\\Roaming\\Python\\Python313\\site-packages\\xgboost\\training.py:183: UserWarning: [18:10:38] WARNING: C:\\actions-runner\\_work\\xgboost\\xgboost\\src\\learner.cc:738: \n",
      "Parameters: { \"use_label_encoder\" } are not used.\n",
      "\n",
      "  bst.update(dtrain, iteration=i, fobj=obj)\n",
      "C:\\Users\\Srishti\\AppData\\Roaming\\Python\\Python313\\site-packages\\xgboost\\training.py:183: UserWarning: [18:10:40] WARNING: C:\\actions-runner\\_work\\xgboost\\xgboost\\src\\learner.cc:738: \n",
      "Parameters: { \"use_label_encoder\" } are not used.\n",
      "\n",
      "  bst.update(dtrain, iteration=i, fobj=obj)\n",
      "C:\\Users\\Srishti\\AppData\\Roaming\\Python\\Python313\\site-packages\\xgboost\\training.py:183: UserWarning: [18:10:43] WARNING: C:\\actions-runner\\_work\\xgboost\\xgboost\\src\\learner.cc:738: \n",
      "Parameters: { \"use_label_encoder\" } are not used.\n",
      "\n",
      "  bst.update(dtrain, iteration=i, fobj=obj)\n",
      "C:\\Users\\Srishti\\AppData\\Roaming\\Python\\Python313\\site-packages\\xgboost\\training.py:183: UserWarning: [18:10:45] WARNING: C:\\actions-runner\\_work\\xgboost\\xgboost\\src\\learner.cc:738: \n",
      "Parameters: { \"use_label_encoder\" } are not used.\n",
      "\n",
      "  bst.update(dtrain, iteration=i, fobj=obj)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "✅ Soft Voting Accuracy (mean of 5-fold CV): 0.9706\n",
      "✅ Stacking Accuracy (mean of 5-fold CV): 0.9668\n"
     ]
    }
   ],
   "source": [
    "from sklearn.ensemble import VotingClassifier, StackingClassifier\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.model_selection import cross_val_score\n",
    "\n",
    "# Use the best models from Step 5\n",
    "best_rf = results['RandomForest']['Best Estimator']\n",
    "best_svm = results['SVM']['Best Estimator']\n",
    "best_xgb = results['XGBoost']['Best Estimator']\n",
    "\n",
    "# ------------------------------------------\n",
    "# 6.1 Hard Voting Classifier (majority vote)\n",
    "# ------------------------------------------\n",
    "voting_clf_hard = VotingClassifier(\n",
    "    estimators=[\n",
    "        ('rf', best_rf),\n",
    "        ('svm', best_svm),\n",
    "        ('xgb', best_xgb)\n",
    "    ],\n",
    "    voting='hard'\n",
    ")\n",
    "\n",
    "# Evaluate hard voting\n",
    "hard_scores = cross_val_score(voting_clf_hard, X_scaled, y_balanced, cv=5, scoring='accuracy')\n",
    "print(\"✅ Hard Voting Accuracy (mean of 5-fold CV):\", round(hard_scores.mean(), 4))\n",
    "\n",
    "\n",
    "# ------------------------------------------\n",
    "# 6.2 Soft Voting Classifier (average probabilities)\n",
    "# ------------------------------------------\n",
    "voting_clf_soft = VotingClassifier(\n",
    "    estimators=[\n",
    "        ('rf', best_rf),\n",
    "        ('svm', best_svm),\n",
    "        ('xgb', best_xgb)\n",
    "    ],\n",
    "    voting='soft'\n",
    ")\n",
    "\n",
    "# Evaluate soft voting\n",
    "soft_scores = cross_val_score(voting_clf_soft, X_scaled, y_balanced, cv=5, scoring='accuracy')\n",
    "print(\"✅ Soft Voting Accuracy (mean of 5-fold CV):\", round(soft_scores.mean(), 4))\n",
    "\n",
    "\n",
    "# ------------------------------------------\n",
    "# 6.3 Stacking Classifier\n",
    "# ------------------------------------------\n",
    "stacking_clf = StackingClassifier(\n",
    "    estimators=[\n",
    "        ('rf', best_rf),\n",
    "        ('svm', best_svm)\n",
    "    ],\n",
    "    final_estimator=LogisticRegression(),\n",
    "    cv=5\n",
    ")\n",
    "\n",
    "# Evaluate stacking\n",
    "stack_scores = cross_val_score(stacking_clf, X_scaled, y_balanced, cv=5, scoring='accuracy')\n",
    "print(\"✅ Stacking Accuracy (mean of 5-fold CV):\", round(stack_scores.mean(), 4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "8dbed655-ac29-4281-a8f7-70a2fb48c053",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Srishti\\AppData\\Roaming\\Python\\Python313\\site-packages\\xgboost\\training.py:183: UserWarning: [18:12:42] WARNING: C:\\actions-runner\\_work\\xgboost\\xgboost\\src\\learner.cc:738: \n",
      "Parameters: { \"use_label_encoder\" } are not used.\n",
      "\n",
      "  bst.update(dtrain, iteration=i, fobj=obj)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "✅ Accuracy: 0.9614\n",
      "✅ Precision: 0.9838\n",
      "✅ Recall: 0.9382\n",
      "✅ F1 Score: 0.9605\n",
      "✅ ROC-AUC Score: 0.9753\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import confusion_matrix, accuracy_score, precision_score, recall_score, f1_score, roc_auc_score, roc_curve\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "# ---- Choose Best Ensemble Model ----\n",
    "best_ensemble = voting_clf_soft  # or stacking_clf, based on Step 6 results\n",
    "\n",
    "# ---- Train/Test Split ----\n",
    "X_train, X_test, y_train, y_test = train_test_split(X_scaled, y_balanced, test_size=0.2, random_state=42, stratify=y_balanced)\n",
    "\n",
    "# ---- Fit & Predict ----\n",
    "best_ensemble.fit(X_train, y_train)\n",
    "y_pred = best_ensemble.predict(X_test)\n",
    "y_proba = best_ensemble.predict_proba(X_test)[:, 1]\n",
    "\n",
    "# ---- Evaluation Metrics ----\n",
    "acc = accuracy_score(y_test, y_pred)\n",
    "prec = precision_score(y_test, y_pred)\n",
    "rec = recall_score(y_test, y_pred)\n",
    "f1 = f1_score(y_test, y_pred)\n",
    "roc_auc = roc_auc_score(y_test, y_proba)\n",
    "\n",
    "print(\"✅ Accuracy:\", round(acc, 4))\n",
    "print(\"✅ Precision:\", round(prec, 4))\n",
    "print(\"✅ Recall:\", round(rec, 4))\n",
    "print(\"✅ F1 Score:\", round(f1, 4))\n",
    "print(\"✅ ROC-AUC Score:\", round(roc_auc, 4))\n",
    "\n",
    "# ---- Confusion Matrix ----\n",
    "cm = confusion_matrix(y_test, y_pred)\n",
    "plt.figure(figsize=(6, 4))\n",
    "sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=['Normal', 'MI'], yticklabels=['Normal', 'MI'])\n",
    "plt.xlabel('Predicted')\n",
    "plt.ylabel('True')\n",
    "plt.title(\"Confusion Matrix\")\n",
    "plt.show()\n",
    "\n",
    "# ---- ROC Curve ----\n",
    "fpr, tpr, _ = roc_curve(y_test, y_proba)\n",
    "plt.figure(figsize=(6, 4))\n",
    "plt.plot(fpr, tpr, label=f'ROC Curve (AUC = {roc_auc:.2f})', color='darkorange')\n",
    "plt.plot([0, 1], [0, 1], 'k--')\n",
    "plt.xlabel('False Positive Rate')\n",
    "plt.ylabel('True Positive Rate')\n",
    "plt.title(\"ROC Curve\")\n",
    "plt.legend(loc='lower right')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "7ab0065b-4f66-4a56-b5d0-8b9e52bb4b2a",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 98%|===================| 1019/1036 [00:38<00:00]       "
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1150x660 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import shap\n",
    "\n",
    "# Use XGBoost or Random Forest for SHAP explanations\n",
    "model = RandomForestClassifier(n_estimators=200, max_depth=10, random_state=42)\n",
    "model.fit(X_train, y_train)\n",
    "\n",
    "# Initialize SHAP explainer\n",
    "explainer = shap.Explainer(model, X_train)\n",
    "shap_values = explainer(X_test)\n",
    "\n",
    "# Summary plot (shows overall feature importance)\n",
    "shap.summary_plot(shap_values, X_test, feature_names=[\n",
    "    'Mean', 'Std', 'Skew', 'Kurtosis', 'RMS',\n",
    "    'FFT1','FFT2','FFT3','FFT4','FFT5','FFT6','FFT7','FFT8','FFT9','FFT10',\n",
    "    'PSD_Mean', 'PSD_Max'\n",
    "])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "e2bc22b8-6662-46d3-9a1a-75529f3d1329",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "✅ Accuracy on original test set: 0.9614\n",
      "🧪 Accuracy on noisy test set: 0.9402\n",
      "📉 Accuracy drop due to noise: 0.0212\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "# Add Gaussian noise to test features\n",
    "X_test_noisy = X_test + np.random.normal(0, 0.05, X_test.shape)\n",
    "\n",
    "# Predict on noisy data\n",
    "y_pred_noisy = best_ensemble.predict(X_test_noisy)\n",
    "\n",
    "# Compare performance\n",
    "acc_clean = accuracy_score(y_test, y_pred)\n",
    "acc_noisy = accuracy_score(y_test, y_pred_noisy)\n",
    "\n",
    "print(\"✅ Accuracy on original test set:\", round(acc_clean, 4))\n",
    "print(\"🧪 Accuracy on noisy test set:\", round(acc_noisy, 4))\n",
    "print(\"📉 Accuracy drop due to noise:\", round(acc_clean - acc_noisy, 4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "31fe6924-9f13-44a4-954a-d90663496231",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.13.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
